home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / corewars / readme < prev    next >
Encoding:
Text File  |  1989-02-14  |  7.1 KB  |  218 lines
  1. /*    Copyrighted (C) 1989 by Na Choon Piaw.  All rights reserved       */
  2.  
  3.  
  4.  
  5. /*    This program and documentation is Public Domain, and may be      */
  6. /*    distributed and copied by everyone provided this header          */
  7. /*    remains intact                              */
  8.  
  9. This is a new version of corewars I'm working on.  It will feature
  10. ONLY 2 player games (I hate 3 or more players on corewars), some limited
  11. amounts of display (using curses) though that will be implemented only
  12. after the non-display functions work.  And an independent, full featured
  13. assembler.  The interpreter will load "binary" code only.
  14.  
  15. Full featured -- 1 physical pass, 2 "in memory" passes.
  16.          symbolic memory addresses, immediate, direct, and indirect
  17.          addressing modes.
  18.  
  19. COREWARS is a where the players each write an assembly language program
  20. that battle each other in the memory of a computer called MARS.  (Memory
  21. Array Redcode Simulator)  The game ends when (1) all the streams of execution
  22. on one side have died out, or (2) when the time limit is up.  In (1) the
  23. winner is the side which still has surviving execution streams.  In (2)
  24. the game is a draw.  Once we are finished with implementing this game,
  25. maybe we can schedule a corewars tournament.
  26.  
  27. My version of corewars implements (hopefully in a short while) the following
  28. instructions from World 7 --- The First Corewars Tournament (with some
  29. modifications) (Note: the first two articles have slightly differing
  30. definitions):
  31.  
  32. INSTRUCTION    MNEUMONIC    CODE    ARGUMENTS    EXPLANATION
  33. Move        mov        1    A B        move contents of
  34.                             address A to address B
  35. Add        add        2    A B        add contents of address
  36.                             A to address B
  37. Subtract    sub        3    A B        subtract contents of
  38.                             address A from address
  39.                             B
  40. Jump        jmp        4      B        Transfer control
  41.                             to address A
  42. Jump if zero    jmz        5    A B        Transfer control
  43.                             to address A if
  44.                             contents of B are
  45.                             greater then 0
  46. Jump if not 0    jmn        6    A B        transfer control to
  47.                             address B if contents
  48.                             of B is != 0
  49. Decrement jump    djn        7    A B        Subtract 1 from
  50. if not zero                        contents of address
  51.                             B and transfer
  52.                             control to
  53.                             address A if contents
  54.                             of address B is != 0
  55. Compare        cmp        8    A B        compare contents of
  56.                             addresses A and B; if
  57.                             they are unequal,
  58.                             skip the next
  59.                             instruction.
  60. Split        spl        9      B        split execution into
  61.                             next instruction and
  62.                             the instruction at A
  63. Data statment    dat        0      B        A nonexecuatble
  64.                             statement; B is the
  65.                             data value.
  66.  
  67.  
  68. Addressing modes:-
  69. immediate mode:        #argument
  70. direct mode:        symbol
  71. indirect mode:        @symbol
  72.  
  73. Expected other differences -
  74. 1)    When +/- are conducted to an address that contains other than a
  75.     data instruction, parameter B is always modified (even in spl
  76.     instructions).  There is no way and add or sub instruction can
  77.     change one type of instruction to another, so the CODE part of
  78.     the table is really rather worthless.
  79. 2)    The assembler will feature the "real" symbol.  In other words,
  80.     you do not have to convert all your symbols into numbers before
  81.     feeding your program to the assembler.
  82.     There will be a reserved symbol, though, called "start" and this
  83.     will be where your code will start executing.
  84.     All symbols are characterized by a ':' character at the end, e.g.
  85.     "start:"
  86. 3)    Separate assembly.  In the interest of modularity and ease of
  87.     debugging (for my code, of course, not for the redcode assembly
  88.     program, so I still don't suggest writing 200 instruction redcode
  89.     programs, even though the assembler permits it), I have decided
  90.     to separate the assembler from the interpreter.  The interpreter
  91.     will have to be fed the preassembled programs, etc. in a special
  92.     format.  (produced by the assembler).
  93.  
  94. 4)    Will not implement stuff like the "<" or the ">".  i.e., decrease
  95.     stuff pointed to by operand, then get that address.
  96.  
  97. 5)    Randomized starting memory for the redcode programs.
  98.     Make corewars more deterministic - predictable.
  99.     Can be implemented later if demand arises.
  100.  
  101. Other expected differences -
  102.  
  103. BUGS!!!
  104.  
  105. BUG REPORT SECTION:-
  106.  
  107. assem/main.c    - The program will not accept files with ".e" anywhere
  108.           in the last portion of it (i.e., the extension)
  109.           These files will be rejected.
  110.           e.g.    "mice.eecs" will be rejected
  111.  
  112. tokenize.c    - The program will not be able to handle comments without
  113.           any delimiters between them and the code.
  114.           e.g.  "mov 0 1;;help" will be tokenized into:
  115.             "mov" "0" "1;;help" which is not acceptable, since
  116.             the later functions like lookup will not be able
  117.             to handle it.
  118.  
  119. play.c/main.c:    - The BIG option (to fully bit map the memory array,
  120.           doesn't work.   I wonder why?)
  121.  
  122. Note:
  123. A.K. Dewdney's THE ARMCHAIR UNIVERSE is available from Freeman (publisher).
  124. I highly recommend buying a copy and reading it.  It's a whole lot
  125. of fun and teaches a lot of great programming techniques.
  126. It's moderately priced at around $13.25, and, in my opinion, worth every
  127. penny.
  128.  
  129. Choon Piaw
  130.  
  131.  
  132. Assembler portion of corewars
  133. Usage:
  134. assem <file1> <file2> .....
  135.  
  136. All output files will have an additional extension ".e"
  137. for instance, if the input file was "help.rc" the ouput file will be "help.e"
  138.  
  139. Assembler limits: 200 instructions
  140.           100 symbols
  141.           255 characters in a string
  142.  
  143. Comments are indicated by a ;
  144. Assembler is not case sensitive.
  145. Remember that this does not conform to ALL the A.K. Dewdney standards
  146. in the implementation of OPCODES/PARAMETERS, but as long as you write
  147. code that does not depend on changing other's opcode, you should be
  148. all right.  The instruction set is standard, however.
  149.  
  150. BUGS:
  151.     Any file starting with a .e extension is rejected automatically
  152.     Any character is recognized as a symbol.  Therefore, in
  153.     mov    0    1;this is a comment
  154.     1;this will be interpreted as a symbol instead of a number with
  155.     a comment following it.  The proper form would be:
  156.     mov    0    1    ;this is a comment
  157.  
  158.  
  159.  
  160. Corewars interpreter
  161. - started 12/14/88 by Na Choon Piaw (The Existentialist)
  162.  
  163. usage:
  164.  
  165. interp cycles file1 file2
  166.  
  167. cycles        -number of machine cycles
  168. file1, file2    -preassembled corewars programs
  169.  
  170. Programmer's documentation for Redcode interpreter
  171.  
  172. Goal:
  173.  
  174. To provide a visual version of corewars that is fast, standard and portable.
  175.  
  176. Modules
  177.  
  178. 1.    int loader(int position)
  179.     -    load up files into main memory to position.
  180.     -    setup the starting pcs
  181.  
  182. 2.    eval
  183.     -    input the memory element + a host of other info
  184.         (including the list of streams)
  185.     -    each of the instructions will be handled by a separate
  186.         subroutine that will be passed just sufficient info to carry
  187.         it out.
  188.  
  189. 3.    control
  190.     -    responsible for keeping track of who's what and passing the
  191.         correct instruction to the evaluator
  192.  
  193. 4.    Display
  194.     -    Display in a visual format (to be decided) what's going on
  195.         in memory at that time.
  196.  
  197. Data Structures
  198.  
  199. Streams of execution are kept as circularly linked list, with split
  200. instructions adding to the linked list, and with trying to execute data
  201. instructions.
  202.  
  203. All parameters will range from 0 to +8000.  Excess will be trimmed off,
  204. negatives will be wrapped back around.
  205.  
  206. Credit where credit is due:
  207.  
  208. Case Larsen wrote and debugged the SUN graphics function interface2.c
  209. Adrain Ho wrote and debugged the loader load.c
  210. I wrote and debugged the rest.
  211.  
  212.  
  213. Na Choon Piaw
  214. c60a-3ci@wolf.berkeley.edu
  215. (soon to be changed)
  216. 301P, 2650 Durant,
  217. Berkeley, CA 94720.
  218.